import { requestClient } from '#/api/request';

/**
 * 系统配置参数对象
 */
export interface SysConfigPo {
  sort: string;   // 固定值: JWT
  key: string;    // 固定值: EXPIRATION 或 REFRESH_THRESHOLD
  value: string;  // 动态值, 界面动态传参
  memo: string;   // 固定值 JWT过期时间 或 自动续期阈值时间
}

/**
 * JWT配置参数
 */
export interface JwtConfigParams {
  tokenExpiry: number;      // Token过期时间（分钟）
  renewalThreshold: number; // 续期阈值（分钟）
  autoRefresh: boolean;     // 自动续期开关
}

/**
 * 保存系统配置
 */
export async function saveSysConfigApi(config: SysConfigPo) {
  return requestClient.post<void>('/sysconfig/save', config);
}

/**
 * 保存JWT配置（调用三次接口分别保存过期时间、续期阈值和自动续期开关）
 */
export async function saveJwtConfigApi(params: JwtConfigParams) {
  const { tokenExpiry, renewalThreshold, autoRefresh } = params;

  // 构建过期时间配置
  const expirationConfig: SysConfigPo = {
    sort: 'JWT',
    key: 'EXPIRATION',
    value: String(tokenExpiry),
    memo: 'JWT过期时间'
  };

  // 构建续期阈值配置
  const refreshThresholdConfig: SysConfigPo = {
    sort: 'JWT',
    key: 'REFRESH_THRESHOLD',
    value: String(renewalThreshold),
    memo: `自动续期阈值时间（${renewalThreshold}分钟，即当剩余时间少于${renewalThreshold}分钟时自动续期）`
  };

  // 构建自动续期开关配置
  const refreshSwitchConfig: SysConfigPo = {
    sort: 'JWT',
    key: 'REFRESH_SWITCH',
    value: autoRefresh ? '1' : '0',
    memo: '自动续期开关'
  };

  // 并发调用三个接口
  const promises = [
    saveSysConfigApi(expirationConfig),
    saveSysConfigApi(refreshThresholdConfig),
    saveSysConfigApi(refreshSwitchConfig)
  ];

  try {
    await Promise.all(promises);
    console.log('JWT配置保存成功');
  } catch (error) {
    console.error('JWT配置保存失败:', error);
    throw error;
  }
}

/**
 * 获取系统配置
 */
export async function getSysConfigApi(sort: string, key: string) {
  // 根据实际API返回情况，可能返回字符串或SysConfigPo对象
  return requestClient.get<string | SysConfigPo>(`/sysconfig/value/${sort}/${key}`);
}

/**
 * 获取JWT配置
 */
export async function getJwtConfigApi(): Promise<JwtConfigParams> {
  console.log('开始获取JWT配置...');

  try {
    console.log('并发调用三个配置API...');

    const [expirationResult, thresholdResult, switchResult] = await Promise.all([
      getSysConfigApi('JWT', 'EXPIRATION'),
      getSysConfigApi('JWT', 'REFRESH_THRESHOLD'),
      getSysConfigApi('JWT', 'REFRESH_SWITCH')
    ]);

    console.log('API调用结果:', {
      expirationResult,
      thresholdResult,
      switchResult
    });

    // 根据实际API返回的数据结构进行解析
    let tokenExpiry = 30;
    let renewalThreshold = 10;
    let autoRefresh = false;

    // 如果API返回的是字符串，直接解析
    if (typeof expirationResult === 'string') {
      tokenExpiry = Number(expirationResult) || 30;
    } else if (expirationResult && typeof expirationResult === 'object' && 'value' in expirationResult) {
      // 如果API返回的是对象，从value字段解析
      tokenExpiry = Number(expirationResult.value) || 30;
    }

    if (typeof thresholdResult === 'string') {
      renewalThreshold = Number(thresholdResult) || 10;
    } else if (thresholdResult && typeof thresholdResult === 'object' && 'value' in thresholdResult) {
      renewalThreshold = Number(thresholdResult.value) || 10;
    }

    // 解析自动续期开关
    if (typeof switchResult === 'string') {
      autoRefresh = switchResult === '1';
    } else if (switchResult && typeof switchResult === 'object' && 'value' in switchResult) {
      autoRefresh = switchResult.value === '1';
    }

    const config = {
      tokenExpiry,
      renewalThreshold,
      autoRefresh
    };

    console.log('解析后的配置:', config);
    console.log('解析详情:', {
      expirationResult类型: typeof expirationResult,
      expirationResult值: expirationResult,
      解析出的tokenExpiry: tokenExpiry,
      thresholdResult类型: typeof thresholdResult,
      thresholdResult值: thresholdResult,
      解析出的renewalThreshold: renewalThreshold,
      switchResult类型: typeof switchResult,
      switchResult值: switchResult,
      解析出的autoRefresh: autoRefresh
    });

    return config;
  } catch (error) {
    console.error('获取JWT配置失败，使用默认值:', error);

    // 返回模拟数据用于测试
    const mockConfig = {
      tokenExpiry: 45,  // 使用不同的默认值来测试
      renewalThreshold: 12,
      autoRefresh: false
    };

    console.log('使用模拟配置:', mockConfig);

    return mockConfig;
  }
}

/**
 * 重载JWT配置（使保存的配置参数生效）
 */
export async function reloadJwtConfigApi() {
  return requestClient.post<void>('/system/jwt-config/reload');
}

/**
 * 获取模拟JWT配置（用于测试）
 */
export async function getMockJwtConfigApi(): Promise<JwtConfigParams> {
  console.log('使用模拟数据...');

  // 模拟API延迟
  await new Promise(resolve => setTimeout(resolve, 1000));

  const mockConfig = {
    tokenExpiry: 90,
    renewalThreshold: 20,
    autoRefresh: true
  };

  console.log('模拟配置返回:', mockConfig);

  return mockConfig;
}
